﻿
using System.Collections.Generic;
using ObjetoNegocio;
using RegraNegocio;

namespace Fachada
{
    public class Fachada:IFachada
    {
       
        #region métodos cadastrar

        public void CadastrarUsuario(Usuario usuario)
        {

        }

        public void CadastrarAlgoritmo(Algoritmo algoritmo)
        {
            new RegraNegocioAlgoritmo().Cadastrar(algoritmo);
        }

        public void CadastrarAtributo(Atributo atributo)
        {

        }

        public void CadastrarAvaliacao(Avaliacao avaliacao)
        {
            new RegraNegocioAvaliacao().Cadastrar(avaliacao);
        }

        public void CadastrarBusca(Busca busca)
        {
            new RegraNegocioBusca().Cadastrar(busca);
        }

        public void CadastrarValor(Valor valor)
        {
        }
        #endregion




        #region métodos atualizar

        public void AtualizarUsuario(Usuario usuario)
        {

        }

        public void AtualizarAlgoritmo(Algoritmo algoritmo)
        {
        }

        public void AtualizarAtributo(Atributo atributo)
        {

        }

        public void AtualizarAvaliacao(Avaliacao avaliacao)
        {
        }
        public void AtualizarrBusca(Busca busca)
        {
        }

        public void AtualizarValor(Valor valor)
        {
        }
        #endregion
        
        #region métodos pesquisar
        public Usuario PesquisarUsuario(Usuario usuario)
        {
           return new RegraNegocioUsuario().Pesquisar(usuario);
        }
        public Algoritmo PesquisarAlgoritmo(decimal codigo)
        {
            return null;
        }
        public Avaliacao PesquisarAvaliacao(decimal codigoUsuario, decimal codigoBusca, decimal codigoAlgoritmo)
        {
            return null;
        }
        
        public Atributo PesquisarAtributo(Atributo atributo)
        {
            return null;
        }

        public List<Atributo> ListarAtributoPorFiltro(Atributo atributo)
        {
            return new RegraNegocioAtributo().ListarPorFiltro(atributo);
        }


        public List<Usuario> ListarUsuarios()
        {
            return new RegraNegocioUsuario().Listar();
        }


        public Valor PesquisarValor(decimal valor)
        {
            return null;
        }

        public Busca PesquisarBusca(Busca busca)
        {
            return null;
        }



        public void RemoverBusca(Busca busca)
        {


        }
        #endregion

        #region métodos para remover


        public void RemoverUsuario(decimal codigo)
        {

        }
        public void RemoverAlgoritmo(decimal codigo)
        {

        }
        public void RemoverAvaliacao(decimal codigoUsuario, decimal codigoBusca, decimal codigoAlgoritmo)
        {
        }

        public void RemoverAtributo(decimal codigo)
        {
        }

        public void RemoverValor(decimal valor)
        {

        }


        #endregion

        #region metodos existe

        public bool ExisteUsuario(decimal codigo)
        {
            return false;
        }
        public bool ExisteAlgoritmo(decimal codigo)
        {
            return false;
        }
        public bool ExisteAvaliacao(decimal codigoUsuario, decimal codigoBusca, decimal codigoAlgoritmo)
        {
            return false;
        }
        public bool ExisteAtributo(decimal codigo)
        {
            return false;
        }

        public bool ExisteValor(decimal valor)
        {
            return false;
        }

        public bool ExisteBusca(Busca busca)
        {
            return false;
        }


        #endregion

        #region outros métodos

        public List<Algoritmo> PesquisarTop5Algoritmos(Busca busca)
        {
            CadastrarBusca(busca);
            return new RegraNegocioAlgoritmo().ListarTop5PorBusca(busca);
        }

        public List<Algoritmo> RecomendarAlgoritmos(List<Avaliacao> avaliacoes)
        {
            
            avaliacoes.ForEach(CadastrarAvaliacao);
            var avaliacaoRn = new RegraNegocioAvaliacao();
            var algoritmos = new List<Algoritmo>();
            if (avaliacoes.Count>0)
            {
                var busca = avaliacoes[0].Busca;
                var usuario = avaliacoes[0].Usuario;
                algoritmos = avaliacaoRn.Recomendar(busca, usuario);
            }

            return algoritmos;
        }

        public List<Atributo> ListarAtributosPorFiltro(Atributo atributo)
        {
            var regraNegocioAtributo = new RegraNegocioAtributo();
            return regraNegocioAtributo.ListarPorFiltro(atributo);
        }


        public List<Algoritmo> ListarAlgoritmos()
        {
            var regraNegocioAlgoritmo = new RegraNegocioAlgoritmo();
            return regraNegocioAlgoritmo.Listar();
        }

        #endregion



    }
}
